{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3m_b50-lZQSv"
      },
      "source": [
        "##### Copyright 2025 Google LLC."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "OaKDLGosZQtV"
      },
      "outputs": [],
      "source": [
        "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pOFvMr50aDYQ"
      },
      "source": [
        "# Virtual Try-On with Gemini 2.5 & Imagen 3\n",
        "\n",
        "<a target=\"_blank\" href=\"https://colab.research.google.com/github/google-gemini/cookbook/blob/main/examples/Virtual_Try_On.ipynb\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" height=30/></a>\n",
        "\n",
        "\n",
        "This notebook is an implementation of virtually trying on different outfits by image editing and inpainting using Imagen 3, along with Gemini 2.5 for creating segmentation masks.\n",
        "\n",
        ">**Note:** This notebook is designed to run on Google Colab. Certain commands, such as `%cd`, are specific to the Colab environment and may not work outside of it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pxoGBmFYG_0Y"
      },
      "source": [
        "<!-- Community Contributor Badge -->\n",
        "<table>\n",
        "  <tr>\n",
        "    <!-- Author Avatar Cell -->\n",
        "    <td bgcolor=\"#d7e6ff\">\n",
        "      <a href=\"https://github.com/NSTiwari\" target=\"_blank\" title=\"View Nitin Tiwari's profile on GitHub\">\n",
        "        <img src=\"https://github.com/NSTiwari.png?size=100\"\n",
        "             alt=\"NSTiwari's GitHub avatar\"\n",
        "             width=\"100\"\n",
        "             height=\"100\">\n",
        "      </a>\n",
        "    </td>\n",
        "    <!-- Text Content Cell -->\n",
        "    <td bgcolor=\"#d7e6ff\">\n",
        "      <h2><font color='black'>This notebook was contributed by <a href=\"https://github.com/NSTiwari\" target=\"_blank\"><font color='#217bfe'><strong>Nitin Tiwari</strong></font></a>.</font></h2>\n",
        "      <h5><font color='black'><a href=\"https://linkedin.com/in/tiwari-nitin\"><font color=\"#078efb\">LinkedIn</font></a> - See <a href=\"https://github.com/NSTiwari\" target=\"_blank\"><font color=\"#078efb\"><strong>Nitin</strong></font></a> other notebooks <a href=\"https://github.com/search?q=repo%3Agoogle-gemini%2Fcookbook%20%22This%20notebook%20was%20contributed%20by%20Nitin%20Tiwari%22&type=code\" target=\"_blank\"><font color=\"#078efb\">here</font></a>.</h5></font><br>\n",
        "      <!-- Footer -->\n",
        "      <font color='black'><small><em>Have a cool Gemini example? Feel free to <a href=\"https://github.com/google-gemini/cookbook/blob/main/CONTRIBUTING.md\" target=\"_blank\"><font color=\"#078efb\">share it too</font></a>!</em></small></font>\n",
        "    </td>\n",
        "  </tr>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WfXrdAikimuH"
      },
      "source": [
        ">**Note:** For the older implementation that used SAM 2.1 to generate segmentation masks, refer to this [notebook](https://github.com/NSTiwari/Virtual-Try-On-Imagen3/blob/main/Virtual_Try_On_Imagen3.ipynb)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NTdhzTxQaaXt"
      },
      "source": [
        "## Before you begin\n",
        "\n",
        "Before starting, ensure you have the following prerequisites in place:\n",
        "\n",
        "* **Gemini API Access:** Make sure you have access to the Gemini API.\n",
        "\n",
        "* **GCP Account:** You’ll need an active GCP account with a billing project set up and the Vertex AI API enabled. If you’re unsure how to get started, follow the instructions in this setup [guide](https://cloud.google.com/vertex-ai/docs/start/cloud-environment).\n",
        "\n",
        "\n",
        "Once you have these ready, you're good to go."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V1bgMAD7aji1"
      },
      "source": [
        "## Step 1: Install Gen AI SDK"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UZQMt8KwaKe0"
      },
      "outputs": [],
      "source": [
        "%pip install -U -q google-genai"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YRyc_6XVatwP"
      },
      "source": [
        "## Step 2: Import libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PMXU_etTavO1"
      },
      "outputs": [],
      "source": [
        "import cv2\n",
        "import numpy as np\n",
        "from PIL import Image as PILImage\n",
        "from matplotlib import pyplot as plt\n",
        "from google import genai\n",
        "from google.genai import types\n",
        "import random\n",
        "import base64\n",
        "from IPython.display import Markdown, HTML\n",
        "from base64 import b64encode\n",
        "import json\n",
        "import io\n",
        "from io import BytesIO\n",
        "\n",
        "from google.colab import userdata, auth\n",
        "auth.authenticate_user()\n",
        "\n",
        "import vertexai\n",
        "from vertexai.preview.vision_models import (\n",
        "    ControlReferenceImage,\n",
        "    Image,\n",
        "    ImageGenerationModel,\n",
        "    MaskReferenceImage,\n",
        "    RawReferenceImage,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmGDNk02a8y1"
      },
      "source": [
        "## Step 3: Configure Gemini API key and GCP Project ID\n",
        "\n",
        "To run the following cell, your Gemini API key must be stored it in a Colab Secret named `GOOGLE_API_KEY`. If you don't already have an API key, or you're not sure how to create a Colab Secret, see [Authentication ![image](https://storage.googleapis.com/generativeai-downloads/images/colab_icon16.png)](../quickstarts/Authentication.ipynb) for an example.\n",
        "\n",
        "Additionally, please also store your GCP Project ID in a Colab Secret named `GCP_PROJECT_ID`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WY0upxT7a9qJ"
      },
      "outputs": [],
      "source": [
        "# Comfigure Gemini API key.\n",
        "GEMINI_API_KEY = userdata.get('GOOGLE_API_KEY')\n",
        "client = genai.Client(api_key=GEMINI_API_KEY)\n",
        "\n",
        "# Configure GCP Project ID for Vertex AI.\n",
        "GCP_PROJECT_ID = userdata.get('GCP_PROJECT_ID')\n",
        "\n",
        "# Configure model.\n",
        "MODEL_ID = \"gemini-2.5-flash\" # @param [\"gemini-2.5-flash-lite\",\"gemini-2.5-flash\",\"gemini-2.5-pro\",\"gemini-3-pro-preview\"] {\"allow-input\":true}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tb89pHMXbDpG"
      },
      "source": [
        "#### System Instructions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MY8bS2DybD3-"
      },
      "outputs": [],
      "source": [
        "bounding_box_system_instructions = \"\"\"\n",
        "    Return bounding boxes as a JSON array with labels. Never return masks or code fencing. Limit to 25 objects.\n",
        "    If an object is present multiple times, name them according to their unique characteristic (colors, size, position, unique characteristics, etc..).\n",
        "\"\"\"\n",
        "\n",
        "safety_settings = [\n",
        "    types.SafetySetting(\n",
        "        category=\"HARM_CATEGORY_DANGEROUS_CONTENT\",\n",
        "        threshold=\"BLOCK_ONLY_HIGH\",\n",
        "    ),\n",
        "]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Nj0WrdW8bMHF"
      },
      "outputs": [],
      "source": [
        "def parse_json(text: str) -> str:\n",
        "    return text.strip().removeprefix(\"```json\").removesuffix(\"```\")\n",
        "\n",
        "\"\"\"\n",
        "Function adapted from:\n",
        "https://github.com/google-gemini/cookbook/blob/main/quickstarts/Spatial_understanding.ipynb\n",
        "\"\"\"\n",
        "def generate_mask(predicted_str: str, *, img_height: int, img_width: int) -> list[tuple[np.ndarray, str]]:\n",
        "    try:\n",
        "        items = json.loads(parse_json(predicted_str))\n",
        "        if not isinstance(items, list):\n",
        "            print(\"Error: Parsed JSON is not a list.\")\n",
        "            return []\n",
        "    except json.JSONDecodeError as e:\n",
        "        print(f\"Error decoding JSON: {e}\")\n",
        "        print(f\"Problematic string snippet: {predicted_str[:200]}...\")\n",
        "        return []\n",
        "    except Exception as e:\n",
        "        print(f\"An unexpected error occurred during JSON parsing: {e}\")\n",
        "        return []\n",
        "\n",
        "    segmentation_data = []\n",
        "    default_label = \"unknown\"\n",
        "\n",
        "    for item_idx, item in enumerate(items):\n",
        "        if not isinstance(item, dict) or \"box_2d\" not in item or \"mask\" not in item:\n",
        "            print(f\"Skipping invalid item structure at index {item_idx}: {item}\")\n",
        "            continue\n",
        "\n",
        "        label = item.get(\"label\", default_label)\n",
        "        if not isinstance(label, str) or not label:\n",
        "            label = default_label\n",
        "\n",
        "        png_str = item[\"mask\"]\n",
        "        if not isinstance(png_str, str) or not png_str.startswith(\"data:image/png;base64,\"):\n",
        "            print(f\"Skipping item {item_idx} (label: {label}) with invalid mask format.\")\n",
        "            continue\n",
        "        png_str = png_str.removeprefix(\"data:image/png;base64,\")\n",
        "        try:\n",
        "            png_bytes = base64.b64decode(png_str)\n",
        "            bbox_mask = cv2.imdecode(np.frombuffer(png_bytes, np.uint8), cv2.IMREAD_GRAYSCALE)\n",
        "            if bbox_mask is None:\n",
        "                print(f\"Skipping item {item_idx} (label: {label}) because mask decoding failed.\")\n",
        "                continue\n",
        "        except (base64.binascii.Error, ValueError, Exception) as e:\n",
        "            print(f\"Error decoding base64 or image data for item {item_idx} (label: {label}): {e}\")\n",
        "            continue\n",
        "\n",
        "        try:\n",
        "            box = item[\"box_2d\"]\n",
        "            if not isinstance(box, list) or len(box) != 4:\n",
        "                print(f\"Skipping item {item_idx} (label: {label}) with invalid box_2d format: {box}\")\n",
        "                continue\n",
        "            y0_norm, x0_norm, y1_norm, x1_norm = map(float, box)\n",
        "            abs_y0 = max(0, min(int(y0_norm / 1000.0 * img_height), img_height - 1))\n",
        "            abs_x0 = max(0, min(int(x0_norm / 1000.0 * img_width), img_width - 1))\n",
        "            abs_y1 = max(0, min(int(y1_norm / 1000.0 * img_height), img_height))\n",
        "            abs_x1 = max(0, min(int(x1_norm / 1000.0 * img_width), img_width))\n",
        "            bbox_height = abs_y1 - abs_y0\n",
        "            bbox_width = abs_x1 - abs_x0\n",
        "            if bbox_height <= 0 or bbox_width <= 0:\n",
        "                print(f\"Skipping item {item_idx} (label: {label}) with invalid bbox dims: {box} -> ({bbox_width}x{bbox_height})\")\n",
        "                continue\n",
        "        except (ValueError, TypeError) as e:\n",
        "            print(f\"Skipping item {item_idx} (label: {label}) due to error processing box_2d: {e}\")\n",
        "            continue\n",
        "\n",
        "        try:\n",
        "            if bbox_mask.shape[0] > 0 and bbox_mask.shape[1] > 0:\n",
        "                resized_bbox_mask = cv2.resize(\n",
        "                    bbox_mask, (bbox_width, bbox_height), interpolation=cv2.INTER_LINEAR\n",
        "                )\n",
        "            else:\n",
        "                print(f\"Skipping item {item_idx} (label: {label}) due to empty decoded mask before resize.\")\n",
        "                continue\n",
        "        except cv2.error as e:\n",
        "            print(f\"Error resizing mask for item {item_idx} (label: {label}): {e}\")\n",
        "            continue\n",
        "\n",
        "        full_mask = np.zeros((img_height, img_width), dtype=np.uint8)  # Start with a black mask (0s)\n",
        "        try:\n",
        "            full_mask[abs_y0:abs_y1, abs_x0:abs_x1] = resized_bbox_mask  # Place the white mask in the right location\n",
        "        except ValueError as e:\n",
        "            print(f\"Error placing mask for item {item_idx} (label: {label}): {e}. Shape mismatch: slice=({bbox_height},{bbox_width}), resized={resized_bbox_mask.shape}. Attempting correction.\")\n",
        "            try:\n",
        "                resized_bbox_mask_corrected = cv2.resize(bbox_mask, (bbox_width, bbox_height), interpolation=cv2.INTER_LINEAR)\n",
        "                full_mask[abs_y0:abs_y1, abs_x0:abs_x1] = resized_bbox_mask_corrected\n",
        "                print(\"  -> Corrected placement.\")\n",
        "            except Exception as inner_e:\n",
        "                print(f\"  -> Failed to correct placement: {inner_e}\")\n",
        "                continue\n",
        "\n",
        "        segmentation_data.append((full_mask, label))\n",
        "\n",
        "    return segmentation_data\n",
        "\n",
        "\n",
        "\"\"\"\n",
        "Function adapted from:\n",
        "https://github.com/google-gemini/cookbook/blob/main/quickstarts/Spatial_understanding.ipynb\n",
        "\"\"\"\n",
        "def create_binary_mask_overlay(\n",
        "    img: PILImage.Image,\n",
        "    segmentation_data: list[tuple[np.ndarray, str]],\n",
        "    alpha: float = 0.8\n",
        ") -> np.ndarray:\n",
        "\n",
        "    binary_mask = np.zeros(img.size[::-1], dtype=np.uint8)\n",
        "\n",
        "    for mask, label in segmentation_data:\n",
        "        if mask is not None and mask.shape == binary_mask.shape:\n",
        "            binary_mask = np.maximum(binary_mask, mask)\n",
        "\n",
        "    result = np.zeros_like(binary_mask, dtype=np.uint8)\n",
        "    result[binary_mask > 0] = 255\n",
        "\n",
        "    return result"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QeIZXmGAcpY9"
      },
      "source": [
        "## Step 4: Referring Expression Segmentation by Gemini 2.5\n",
        "\n",
        "Pass the image, and the object to be segmented as part of the text prompt to Gemini 2.5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ITxSPUKPc0_f"
      },
      "outputs": [],
      "source": [
        "# Get a sample image.\n",
        "!wget -q https://storage.googleapis.com/generativeai-downloads/images/Virtual_try_on_person.png -O /content/image_01.png"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L-OCf4KkcpBe"
      },
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<Figure size 1126x1506 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "input_image = 'image_01.png' # @param {type : 'string'}\n",
        "object_to_segment = 'hoodie' # @param {type: 'string'}\n",
        "\n",
        "prompt = f\"Give the segmentation masks for {object_to_segment}. Output a JSON list of segmentation masks where each entry contains the 2D bounding box in the key 'box_2d', the segmentation mask in key 'mask', and the text label in the key 'label'.\"\n",
        "\n",
        "image_path = f\"/content/{input_image}\"\n",
        "img = PILImage.open(image_path)\n",
        "\n",
        "# Run model and generate segmentation masks.\n",
        "img_height, img_width = img.size[1], img.size[0]\n",
        "response = client.models.generate_content(\n",
        "    model=MODEL_ID,\n",
        "    contents=[prompt, img],\n",
        "    config=types.GenerateContentConfig(\n",
        "        temperature=0.5,\n",
        "        safety_settings=safety_settings,\n",
        "    )\n",
        ")\n",
        "\n",
        "result = response.text\n",
        "segmentation_data = generate_mask(result, img_height=img_height, img_width=img_width)\n",
        "\n",
        "# Create binary mask overlay.\n",
        "if segmentation_data:\n",
        "    binary_mask = create_binary_mask_overlay(img, segmentation_data, alpha=0.8)\n",
        "    cv2.imwrite(f\"annotation_mask_{input_image}\", binary_mask)\n",
        "else:\n",
        "    print(\"No segmentation mask found.\")\n",
        "\n",
        "img_array = np.array(img)\n",
        "binary_array = np.array(binary_mask)\n",
        "\n",
        "binary_array_3d = np.expand_dims(binary_array, axis=2)\n",
        "binary_array_3d = np.repeat(binary_array_3d, 3, axis=2)\n",
        "\n",
        "gap_width = 20\n",
        "empty_img = np.full((img_array.shape[0], gap_width, img_array.shape[2]), 255, dtype=img_array.dtype)\n",
        "combined_image = np.hstack((img_array, empty_img, binary_array_3d))\n",
        "\n",
        "fig, axes = plt.subplots(1, 1, figsize=(img_array.shape[1] / 50, img_array.shape[0] / 50))\n",
        "\n",
        "axes.imshow(combined_image)\n",
        "axes.axis('off')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loN5Yx5YeLPe"
      },
      "source": [
        "## Step 5: Configure Imagen 3 parameters\n",
        "\n",
        "Next, certain parameters need to be configured as follows:\n",
        "\n",
        "* `Base image`: The input image file to be edited.\n",
        "* `Mask file:`: The binary mask of the object to be inpainted.\n",
        "* `Edit mode`: Options like inpainting-insert, inpainting-remove, or outpainting.\n",
        "* `Mask mode`: Background or foreground\n",
        "* `Dilation`: A float value between 0 and 1 indicating the percentage of the provided mask."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DJ7Cmkm8eL1T"
      },
      "outputs": [],
      "source": [
        "mask_file = f\"/content/annotation_mask_{input_image}\"\n",
        "output_file = f\"/content/output_{input_image}\"\n",
        "prompt = \"A dark green jacket, white shirt inside it\" # @param {type: 'string'}\n",
        "\n",
        "edit_mode = 'inpainting-insert' # @param ['inpainting-insert', 'outpainting', 'inpainting-remove']\n",
        "mask_mode = 'foreground' # @param ['foreground', 'background']\n",
        "dilation = 0.01 # @param {type:\"slider\", min:0, max:1, step:0.01}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CNCe6eedeOMu"
      },
      "source": [
        "## Step 6: Generate and inpaint new image using Imagen 3\n",
        "\n",
        "Finally, the image is ready to be generated and edited using Imagen 3.\n",
        "\n",
        ">**Note:** For accurate image generation and editing, ensure a precise mask of the object is provided. Additionally, a detailed prompt should be given for the image to be generated. Achieving optimal results may require several attempts."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lVw5sFNxePFd"
      },
      "outputs": [],
      "source": [
        "vertexai.init(project=GCP_PROJECT_ID, location=\"us-central1\")\n",
        "\n",
        "edit_model = ImageGenerationModel.from_pretrained(\"imagen-3.0-capability-001\")\n",
        "\n",
        "base_img = Image.load_from_file(location=image_path)\n",
        "mask_img = Image.load_from_file(location=mask_file)\n",
        "\n",
        "raw_ref_image = RawReferenceImage(image=base_img, reference_id=0)\n",
        "mask_ref_image = MaskReferenceImage(\n",
        "    reference_id=1, image=mask_img, mask_mode=mask_mode, dilation=dilation\n",
        ")\n",
        "\n",
        "edited_image = edit_model.edit_image(\n",
        "    prompt=prompt,\n",
        "    edit_mode=edit_mode,\n",
        "    reference_images=[raw_ref_image, mask_ref_image],\n",
        "    number_of_images=1,\n",
        "    safety_filter_level=\"block_some\",\n",
        "    person_generation=\"allow_adult\",\n",
        ")\n",
        "\n",
        "edited_image[0].save(output_file)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fXc2ojmIeS32"
      },
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<PIL.PngImagePlugin.PngImageFile image mode=RGB size=563x753>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "output_file = PILImage.open('/content/output_image_01.png')\n",
        "display(output_file)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g_1l-hSWeT-O"
      },
      "source": [
        "Congratulations on successfully completing this tutorial and building a Virtual Try-On application using Gemini 2.5's segmentation and Imagen 3's powerful image generation capabilities."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "3m_b50-lZQSv"
      ],
      "name": "Virtual_Try_On.ipynb",
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
